#include<QApplication>
#include<QDesktopWidget>
#include"fenetre.h"
#include<QStringList>
#include<iostream>
#include<QSettings>
#include<QDialog>
#include"boiteDialog.h"
#include"edt.h"

Fenetre::Fenetre(): QWidget()
{

    //definition du layout principal
    layoutPrincipal_ = new QHBoxLayout();
        //creation de tabs pour les onglets
        onglets_ = new QTabWidget(this);
        /*ajout des onglets au layout principal*/
        layoutPrincipal_->addWidget(onglets_);
        //layoutPrincipal_->addLayout(vBoxAccesEDT_);

        /*creation du Bouton pour la modification*/
        boutonModifier_ = new OrientationButton("^^^");
        boutonModifier_->setOrientation(Qt::Vertical);
        boutonModifier_->setCheckable(true);
        layoutPrincipal_->addWidget(boutonModifier_);

    //definition des onglets
    page1_ = new QWidget();
    page2_ = new QWidget();
    page3_ = new QWidget();
    page4_ = new QWidget();
    page5_ = new QWidget();
    page6_ = new QWidget();

    /*page 1*/
        /*definition du conteneur de l'onglet 1*/
        vBoxEtu_ = new QVBoxLayout();
        /*definition des champs du formulaire*/
        noEtu_ = new QLineEdit(page1_);
        nomEtu_ = new QLineEdit(page1_);
        prenomEtu_ = new QLineEdit(page1_);
        adrPostEtu_ = new QLineEdit(page1_);
        adrElecEtu_ = new QLineEdit(page1_);

        /*definition du formulaire*/
        formEtu_ = new QFormLayout();
        /*ajout des champs au formulaire*/
        formEtu_->addRow("&Identifiant de l'étudiant", noEtu_);
        formEtu_->addRow("&Nom de l'étudiant", nomEtu_);
        formEtu_->addRow("&Prenom de l'étudiant", prenomEtu_);
        formEtu_->addRow("&Adresse Postale", adrPostEtu_);
        formEtu_->addRow("Adresse &Electronique", adrElecEtu_);
        /*ajout du formulaire au conteneur vertical*/
        vBoxEtu_->addLayout(formEtu_);

        /*definition d'une grille*/
        ButtonValidEtuLayout_ = new QGridLayout();

        /*définition des boutons de création et d'annulation*/
        createEtu_ = new QPushButton("Créer Etudiant");
        resetEtu_ = new QPushButton("Annuler");
        /*définition des boutons de modification et de suppression*/
        modifEtu_ = new QPushButton("Modifier Etudiant");
        supprimerEtu_ = new QPushButton("Supprimer Etudiant");
        /*ajout des boutons au gridLayout*/
        ButtonValidEtuLayout_->addWidget(createEtu_, 0,0);
        ButtonValidEtuLayout_->addWidget(resetEtu_, 0,1);
        ButtonValidEtuLayout_->addWidget(modifEtu_,1,0);
        ButtonValidEtuLayout_->addWidget(supprimerEtu_,1,1);
        modifEtu_->setHidden(true);
        supprimerEtu_->setHidden(true);
        /*ajout du GridLayout au conteneur de la page 1*/
        vBoxEtu_->addLayout(ButtonValidEtuLayout_);

        /*ajout du conteneur vertical dans l'onglet etudiant*/
        page1_->setLayout(vBoxEtu_);

        /*signaux de l'onglet 1*/
        QObject::connect(createEtu_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(creerEtudiant()));

        QObject::connect(resetEtu_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(razEtu()));

        QObject::connect(modifEtu_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(modifEtudiant()));

        QObject::connect(supprimerEtu_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(supprEtudiant()));

    /*page 2*/
        /*definition du conteneur de l'onglet 2*/
        vBoxEns_ = new QVBoxLayout();
        /*definition des champs du formulaire*/
        noEns_ = new QLineEdit(page2_);
        nomEns_ = new QLineEdit(page2_);
        prenomEns_ = new QLineEdit(page2_);
        adrPostEns_ = new QLineEdit(page2_);
        adrElecEns_ = new QLineEdit(page2_);

        /*definition du formulaire*/
        formEns_ = new QFormLayout();
        /*ajout des champs au formulaire*/
        formEns_->addRow("&Identifiant de l'enseignant", noEns_);
        formEns_->addRow("&Nom de l'enseignant", nomEns_);
        formEns_->addRow("&Prenom de l'enseignant", prenomEns_);
        formEns_->addRow("&Adresse Postale", adrPostEns_);
        formEns_->addRow("Adresse &Electronique", adrElecEns_);
        /*ajout du formulaire au conteneur vertical*/
        vBoxEns_->addLayout(formEns_);

        /*definition d'une grille*/
        ButtonValidEnsLayout_ = new QGridLayout();

        /*définition des boutons de création et d'annulation*/
        createEns_ = new QPushButton("Créer Enseignant");
        resetEns_ = new QPushButton("Annuler");
        /*définition des boutons de modification et de suppression*/
        modifEns_ = new QPushButton("Modifier Enseignant");
        supprimerEns_ = new QPushButton("Supprimmer Enseignant");
        /*ajout des boutons au gridLayout*/
        ButtonValidEnsLayout_->addWidget(createEns_, 0,0);
        ButtonValidEnsLayout_->addWidget(resetEns_,0,1);
        ButtonValidEnsLayout_->addWidget(modifEns_,1,0);
        ButtonValidEnsLayout_->addWidget(supprimerEns_,1,1);
        modifEns_->setHidden(true);
        supprimerEns_->setHidden(true);
        /*ajout du GridLayout au formulaire*/
        vBoxEns_->addLayout(ButtonValidEnsLayout_);

        /*ajout du conteneur vertical dans l'onglet enseignant*/
        page2_->setLayout(vBoxEns_);

        /*signaux de l'onglet 2*/
        QObject::connect(createEns_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(creerEnseignant()));

        QObject::connect(resetEns_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(razEns()));

        QObject::connect(modifEns_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(modifEnseignant()));

        QObject::connect(supprimerEns_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(supprEnseignant()));



    /*page 3*/
        /*définition du conteneur de l'onglet 3*/
        vBoxSalle_ = new QVBoxLayout();
        /*définition des champs du formulaire*/
        noSalle_ = new QLineEdit(page3_);
        capacite_ = new QLineEdit(page3_);

        /*définition du formulaire*/
        formSalle_ = new QFormLayout();
        /*ajout des champs au formulaire*/
        formSalle_->addRow("&Numéro de la salle", noSalle_);
        formSalle_->addRow("&Capacité de la salle", capacite_);
        /*ajout du formulaire au conteneur vertical*/
        vBoxSalle_->addLayout(formSalle_);

        /*définition du choix de type de salle*/
        choixType_ = new QGroupBox(page3_);
            /*définition des boutons du type de salle*/
            radioTypeCM_ = new QRadioButton("Salle de CM");
            radioTypeTD_ = new QRadioButton("Salle de TD");
            radioTypeTP_ = new QRadioButton("Salle de TP");
            /*on force la selection de salle de CM*/
            radioTypeCM_->setChecked(true);
            /*definition du conteneur des boutons*/
            choixTypeLayout_ = new QHBoxLayout();
            /*ajout des boutons au conteneur de boutons*/
            choixTypeLayout_->addWidget(radioTypeCM_);
            choixTypeLayout_->addWidget(radioTypeTD_);
            choixTypeLayout_->addWidget(radioTypeTP_);
        /*définition du conteneur pour le groupe de boutons*/
        choixType_->setLayout(choixTypeLayout_);
        /*ajout du groupe de bouton au conteneur de la page 3*/
        vBoxSalle_->addWidget(choixType_);

        /*definition du conteneur des options*/
        choixDispoLayout_ = new QHBoxLayout();
        /*définition des options*/
        checkVideoProj_ = new QCheckBox("Vidéo projecteur");
        checkVisioConf_ = new QCheckBox("Visio-conférence");
        nbMachine_ = new QLineEdit(page3_);

        /*ajout des options au conteneur d'option*/
        choixDispoLayout_->addWidget(checkVideoProj_);
        choixDispoLayout_->addWidget(checkVisioConf_);
        choixDispoLayout_->addWidget(nbMachine_);
        /*on cache le layout inutile*/
        checkVideoProj_->setHidden(true);
        nbMachine_->setHidden(true);



        /*ajout des options au conteneur de la page 3*/
        vBoxSalle_->addLayout(choixDispoLayout_);

        /*definition d'un grille*/
        ButtonValidSalleLayout_ = new QGridLayout();
        /*définition des boutons de création et d'annulation*/
        createSalle_ = new QPushButton("Créer Salle");
        resetSalle_ = new QPushButton("Annuler");
        /*définition des boutons de modification et de suppression*/
        modifSalle_ = new QPushButton("Modifier Salle");
        supprimerSalle_ = new QPushButton("Supprimer Salle");
        /*ajout des boutons au gridLayout*/
        ButtonValidSalleLayout_->addWidget(createSalle_, 0,0);
        ButtonValidSalleLayout_->addWidget(resetSalle_,0,1);
        ButtonValidSalleLayout_->addWidget(modifSalle_,1,0);
        ButtonValidSalleLayout_->addWidget(supprimerSalle_,1,1);
        modifSalle_->setHidden(true);
        supprimerSalle_->setHidden(true);
        /*ajout du Grid Layout au conteneur de la page 3*/
        vBoxSalle_->addLayout(ButtonValidSalleLayout_);

        /*ajout du conteneur de la page 3 dans l'onglet 3*/
        page3_->setLayout(vBoxSalle_);

        /*signaux de l'onglet 3*/
        /*ajout des signaux pour le changement de type de salle*/
        QObject::connect(createSalle_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(creerSalle()));

        QObject::connect(resetSalle_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(razSalle()));

        QObject::connect(modifSalle_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(modifSalle()));

        QObject::connect(supprimerSalle_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(supprSalle()));


        QObject::connect(radioTypeTD_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(changeOptionTD()));

        QObject::connect(radioTypeCM_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(changeOptionCM()));

        QObject::connect(radioTypeTP_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(changeOptionTP()));


    /*page 4 - module*/
        /*Définition du conteneur de la page 4*/
        vBoxModule_ = new QVBoxLayout();
        /*définition du formulaire*/
        formMod_ = new QFormLayout();
        /*définition des champs du formualire*/
        idMod_ = new QLineEdit(page4_);
        titreMod_ = new QLineEdit(page4_);
        /*ajout des champs au formulaire*/
        formMod_->addRow("&Identifiant du module", idMod_);
        formMod_->addRow("&Titre du module", titreMod_);
        /*ajout du formulaire au conteneur*/
        vBoxModule_->addLayout(formMod_);

        /*définition du conteneur de choix d'horaires*/
        choixHeures_ = new QGridLayout();

        /*définition du contenu de la grille*/
        nbHCM_ = new QLineEdit("8",page4_);
        nbHTD_ = new QLineEdit("16",page4_);
        nbHTP_ = new QLineEdit("16",page4_);
        labHCM_ = new QLabel("Nombre d'heure de CM",page4_);
        labHTD_ = new QLabel("Nombre d'heure de TD",page4_);
        labHTP_ = new QLabel("Nombre d'heure de TP",page4_);
        /*ajout des champs à la grille*/
        choixHeures_->addWidget(labHCM_,0,0);
        choixHeures_->addWidget(labHTD_,0,1);
        choixHeures_->addWidget(labHTP_,0,2);
        choixHeures_->addWidget(nbHCM_,1,0);
        choixHeures_->addWidget(nbHTD_,1,1);
        choixHeures_->addWidget(nbHTP_,1,2);
        /*ajout de la grille à la page 4*/
        vBoxModule_->addLayout(choixHeures_);

        /*définition du layout d'affichage des enseignants*/
            /*défintion du conteneur d'ajout d'enseignant*/
            ajoutEnsLayout_ = new QHBoxLayout();
            /*définition du contenu de la grille*/
            idEnsLabel_ = new QLabel("");
            nomEnsLabel_ = new QLabel("",page4_);
            prenomEnsLabel_ = new QLabel("", page4_);
            ajoutEns_ = new QPushButton("ajout enseignant",page4_);
            /*ajout des widgets à la grille*/
            ajoutEnsLayout_->addWidget(nomEnsLabel_);
            ajoutEnsLayout_->addWidget(prenomEnsLabel_);
            ajoutEnsLayout_->addWidget(ajoutEns_);
            /*ajout de la grille à la page 4*/
            vBoxModule_->addLayout(ajoutEnsLayout_);

        /*définition de la grille de validation*/
        ButtonValidModuleLayout_ = new QGridLayout();
            /*définition des boutons de création et d'annuation*/
        createModule_ = new QPushButton("Créer Module");
        resetModule_ = new QPushButton("Annuler");
        modifModule_ = new QPushButton("Modifier Module");
        supprModule_ = new QPushButton("Supprimer Module");
        /*ajout des boutons au gridLayout*/
        ButtonValidModuleLayout_->addWidget(createModule_,0,0);
        ButtonValidModuleLayout_->addWidget(resetModule_,0,1);
        ButtonValidModuleLayout_->addWidget(modifModule_, 1,0);
        ButtonValidModuleLayout_->addWidget(supprModule_, 1,1);
        modifModule_->setDisabled(true);
        modifModule_->setHidden(true);
        supprModule_->setHidden(true);
        /*ajout de la grille à la page 4*/
        vBoxModule_->addLayout(ButtonValidModuleLayout_);

        /*ajout du conteneur de la page 4 à la page 4*/
        page4_->setLayout(vBoxModule_);

        /*siganux de la page 4*/
        /*ajout du signal pour la création des enseignants*/
        QObject::connect(ajoutEns_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(ajoutEnseignant()));

        QObject::connect(createModule_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(creerModule()));

        QObject::connect(resetModule_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(razModule()));

        QObject::connect(supprModule_,
                         SIGNAL(clicked()),
                         this,
                         SLOT(supprModule()));


        //page 5 - groupes
            /*définition du conteneur de la page 5*/
            vBoxGroupe_ = new QVBoxLayout();
            /*définfitio du formulaire pour les groupes*/
            formGrp_ = new QFormLayout();
                /*définiftion du contenu du formulaire*/
                nomGrp_ = new QLineEdit(page5_);
                /*ajout des champs au formulaire*/
                formGrp_->addRow("&Nom du Groupe", nomGrp_);
                /*ajout du formulaire au conteneur*/
                vBoxGroupe_->addLayout(formGrp_);

            /*définfition du bouton d'ajout d'étudiants et de modules*/
            addGrpMod_ = new QPushButton("Ajouter modules et étudiants");
            addGrpMod_->setDisabled(true);
            /*ajout du bouton au conteneur*/
            vBoxGroupe_->addWidget(addGrpMod_);

            /*définition d'une grille*/
            ButtonValidGroupeLayout_ = new QGridLayout();
                /*définition des boutons de création et annulation*/
                createGrp_ = new QPushButton("Créer groupe");
                resetGrp_ = new QPushButton("Annuler");
                /*défintion des boutons de modfications et de suppression*/
                modifGrp_ = new QPushButton("Modifier groupe");
                supprGrp_ = new QPushButton("Supprimer groupe");
                modifGrp_->setDisabled(true);
                modifGrp_->setHidden(true);
                supprGrp_->setHidden(true);
                /*ajout des boutons à la grille*/
                ButtonValidGroupeLayout_->addWidget(createGrp_,0,0);
                ButtonValidGroupeLayout_->addWidget(resetGrp_,0,1);
                ButtonValidGroupeLayout_->addWidget(modifGrp_,1,0);
                ButtonValidGroupeLayout_->addWidget(supprGrp_,1,1);
            /*ajout de la grille au conteneur*/
            vBoxGroupe_->addLayout(ButtonValidGroupeLayout_);
            /*ajout du conteneur à la page 5*/
                page5_->setLayout(vBoxGroupe_);

            /*signaux de la page 5*/
            QObject::connect(createGrp_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(creerGroupe()));

            QObject::connect(resetGrp_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(razGroupe()));

            QObject::connect(supprGrp_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(supprGroupe()));

        /*page 6*/
         /*définition du conteneur de la page 6*/
         vBoxCreneau_ = new QVBoxLayout();
            /*définition du formulaire*/
            formCreneau_ = new QFormLayout();
            /*définition du contenu du formulaire*/
                dateEdit_ = new QLineEdit(page6_);
                heureEdit_ = new QLineEdit(page6_);
            /*ajout du contenu au formulaire*/
                formCreneau_->addRow("&Entrer la date au format jj/mm/yyyy", dateEdit_);
                formCreneau_->addRow("Entrer une heure pleine", heureEdit_);
        /*ajout du formulaire à la page 6*/
        vBoxCreneau_->addLayout(formCreneau_);

        /*définition de la grille d'ajout*/
        ajoutLayoutCre_ = new QGridLayout();
            /*définition du contenu de la grille*/
            numSalleCre_ = new QLabel("");
            nomGrpCre_ = new QLabel("");
            idModCre_ = new QLabel("");
            ajoutSalle_ = new QPushButton("Ajouter salle", page6_);
            ajoutGroupe_ = new QPushButton("Ajouter groupe", page6_);
            ajoutModule_ = new QPushButton("Ajouter Module", page6_);
        /*ajout du contenu à la grille d'ajout*/
            ajoutLayoutCre_->addWidget(numSalleCre_,0,0);
            ajoutLayoutCre_->addWidget(nomGrpCre_,1,0);
            ajoutLayoutCre_->addWidget(idModCre_,2,0);
            ajoutLayoutCre_->addWidget(ajoutSalle_,0,1);
            ajoutLayoutCre_->addWidget(ajoutGroupe_, 1,1);
            ajoutLayoutCre_->addWidget(ajoutModule_,2,1);
        /*ajout de la grille à la page 6*/
            vBoxCreneau_->addLayout(ajoutLayoutCre_);

        /*définition de la grille de validation*/
        ButtonValidCreneauLayout_ = new QGridLayout();
            /*définition des boutons de création et d'annulation*/
            createCreneau_ = new QPushButton("Créer creneau", page6_);
            resetCreneau_ = new QPushButton("Annuler", page6_);
            /*définition des boutons de modification et de suppression*/
            modifCreneau_ = new QPushButton("Modifier Créneau", page6_);
            supprCreneau_ = new QPushButton("Supprimer Créneau", page6_);
            modifCreneau_->setDisabled(true);
            modifCreneau_->setHidden(true);
            supprCreneau_->setHidden(true);
        /*ajout des boutons à la grille*/
        ButtonValidCreneauLayout_->addWidget(createCreneau_, 0,0);
        ButtonValidCreneauLayout_->addWidget(resetCreneau_, 0,1);
        ButtonValidCreneauLayout_->addWidget(modifCreneau_, 1,0);
        ButtonValidCreneauLayout_->addWidget(supprCreneau_, 1,1);
        /*ajout de la grille de validation à la page 6*/
        vBoxCreneau_->addLayout(ButtonValidCreneauLayout_);
        /*ajout du conteneur de la page 6*/
            page6_->setLayout(vBoxCreneau_);

            /*signaux de la page 6*/
            QObject::connect(ajoutSalle_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(ajoutSalle()));

            QObject::connect(ajoutModule_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(ajoutModule()));

            QObject::connect(ajoutGroupe_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(ajoutGroupe()));

            QObject::connect(createCreneau_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(creerCreneau()));

            QObject::connect(resetCreneau_,
                             SIGNAL(clicked()),
                             this,
                             SLOT(razCreneau()));


    /*fin tabs*/

    //ajout des onglets au QTabWidget
    onglets_->addTab(page1_,"Etudiant");
    onglets_->addTab(page2_, "Enseignant");
    onglets_->addTab(page3_,"Salle");
    onglets_->addTab(page4_,"Module");
    onglets_->addTab(page5_,"Groupe");
    onglets_->addTab(page6_,"Creneau");



    //ACCEDER A L EDT
        vBoxAccesEDT_ = new QVBoxLayout(this);
        vBoxAccesEDT_->addLayout(layoutPrincipal_);
        boutonAccesEDT_ = new QPushButton("Accéder à l'EDT");
        vBoxAccesEDT_->addWidget(boutonAccesEDT_);
        fenetreEDT_ = new Edt(this);
        QObject::connect(boutonAccesEDT_, SIGNAL(clicked()), fenetreEDT_, SLOT(show()));

    /*création de la boite de d'ajout d'objets*/
    dia_ = new DialogAjout(this, Qt::Tool);
    dia_->setModal(true);
    /*assignation des signaux*/
    dialogModif_ = new BoiteDialog(this, Qt::Tool);
    //bouton modifier
    QObject::connect(boutonModifier_,
                     SIGNAL(toggled(bool)),
                     this,
                     SLOT(afficheModifLayout(bool)));

    //changement d'onglet
    QObject::connect(onglets_,
                     SIGNAL(currentChanged(int)),
                     this,
                     SLOT(changeTab(int)));


    /*récupération du contenu sélectionné*/
    QObject::connect(dia_->getViewList(),
                     SIGNAL(doubleClicked(QModelIndex)),
                     this,
                     SLOT(getAnswer(QModelIndex)));




}

Fenetre::~Fenetre()
{
}

QTabWidget* Fenetre::getTabWidget() const
{
    return onglets_;
}

void Fenetre::changeTab(int i)
{
    dialogModif_->changeTab(i);
}

void Fenetre::afficheModifLayout(bool b)
{
    if(b)//lorsque le bouton est actif
    {
        /*modification de la position de la fenetre principal pour
eviter la superposition avec la fenetre de dialogue*/
        QDesktopWidget desk;
       int desktopSize = desk.screenGeometry().size().width();
       if(pos().x()+width()+4+dialogModif_->width()>desktopSize)
           move(desktopSize-dialogModif_->width()-8-pos().x()-width()+pos().x(),pos().y());


        dialogModif_->show();
        dialogModif_->move(pos().x()+width()+4, height()/2+pos().y()-dialogModif_->height()/2);
        boutonModifier_->setMirrored(true);//on applique un effet de mirroir au bouton de modification
    }
    else//lorsque le bouton est inactif
    {
        dialogModif_->hide();
        boutonModifier_->setMirrored(false);//on enleve l'effet mirroir
    }
}


BoiteDialog* Fenetre::getBoiteDialog()
{
    return dialogModif_;
}

void Fenetre::setTaille(QSize t)
{
    taille_ = t;
}

QSize Fenetre::getTaille() const
{
    return taille_;
}

void Fenetre::setPosition(QPoint p)
{
    pos_ = p;
}

QPoint Fenetre::getPosition() const
{
    return pos_;
}

OrientationButton* Fenetre::getBoutonModif()
{
    return boutonModifier_;
}

Controleur* Fenetre::getControleur()
{
    return &control_;
}

void Fenetre::centrerHorizontalement()
{
    QDesktopWidget bureau;
    QPoint point(pos());
    QRect surface_bureau = bureau.screenGeometry();
    int x = surface_bureau.width()/2 - width()/2;
    point.setX(x);
    move(point);
}

void Fenetre::centrer()
{
    QDesktopWidget bureau;
    QRect surface_bureau = bureau.screenGeometry();
    int x = surface_bureau.width()/2 - width()/2;
    int y = surface_bureau.height()/2 - height()/2;
    move(x,y);
}

void Fenetre::changeOptionTD()
{
    checkVisioConf_->setHidden(true);
    nbMachine_->setHidden(true);
    checkVideoProj_->setHidden(false);
}

void Fenetre::changeOptionCM()
{
    nbMachine_->setHidden(true);
    checkVideoProj_->setHidden(true);
    checkVisioConf_->setHidden(false);
}

void Fenetre::changeOptionTP()
{
    checkVideoProj_->setHidden(true);
    checkVisioConf_->setHidden(true);
    nbMachine_->setHidden(false);
}

void Fenetre::CheckExpended(QModelIndex index)
{
    getBoiteDialog()->getTreeModif()->collapseAll();
    getBoiteDialog()->getTreeModif()->blockSignals(true);
    getBoiteDialog()->getTreeModif()->expand(index);
    getBoiteDialog()->getTreeModif()->blockSignals(false);
}

void Fenetre::getData(QModelIndex index)
{
    QAbstractItemModel* modelActuel = getBoiteDialog()->getTreeModif()->model();
    if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_ETUDIANT))
    {//modele Etudiant
        getDataEtu(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT))
    {//modele Enseignant
        getDataEns(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_SALLE))
    {//modele Salle
        getDataSalle(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_MODULE))
    {//modele Module
        getDataModule(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_GROUPE))
    {//modele Groupe
        getDataGroupe(index);
    }
}

void Fenetre::setCreate(QModelIndex index)
{
    QAbstractItemModel* modelActuel = getBoiteDialog()->getTreeModif()->model();
    if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_ETUDIANT))
    {//modele Etudiant
        setCreateEtu(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT))
    {//modele Enseignant
        setCreateEns(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_SALLE))
    {//modele Salle
        setCreateSalle(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_MODULE))
    {//modele Module
        setCreateModule(index);
    }
    else if(modelActuel==getBoiteDialog()->getModel(MODELTYPE_GROUPE))
    {//modele Groupe
        setCreateGroupe(index);
    }
}

void Fenetre::getAnswer(QModelIndex index)
{
    int i = dia_->getTypeModel();
    if(i==MODELTYPE_ENSEIGNANT)
    {//modele Enseignant
        getAnswerEns(index);
    }
    else if(i==MODELTYPE_SALLE)
    {//modele Salle
        getAnswerSalle(index);
    }
    else if(i==MODELTYPE_MODULE)
    {//modele Module
        getAnswerModule(index);
    }
    else if(i==MODELTYPE_GROUPE)
    {//modele Groupe
        getAnswerGroupe(index);
    }
    dia_->close();
}

/*méthode appliqué au étudiant*/
void Fenetre::creerEtudiant()
{
        control_.ajouterEtudiant(noEtu_->text(), nomEtu_->text(), prenomEtu_->text(), adrPostEtu_->text(), adrElecEtu_->text());
        control_.refreshTreeViewEtu(getBoiteDialog()->getModel(MODELTYPE_ETUDIANT));
        razEtu();

}

void Fenetre::razEtu()
{
    noEtu_->clear();
    nomEtu_->clear();
    prenomEtu_->clear();
    adrPostEtu_->clear();
    adrElecEtu_->clear();
}

void Fenetre::getDataEtu(QModelIndex index)
{
    createEtu_->setHidden(true);
    resetEtu_->setHidden(true);
    modifEtu_->setHidden(false);
    supprimerEtu_->setHidden(false);
    noEtu_->setDisabled(true);
    /*fait en sorte qu'il n'y ai qu'un objet d'ouvert*/
    CheckExpended(index);
    QString noEtu = index.data().toString().split(QRegExp(" "), QString::SkipEmptyParts).last();
    Etudiant* etu = (control_.getEtudiant(noEtu.toStdString()));
    noEtu_->setText(QString::fromStdString(etu->getNoe()));
    nomEtu_->setText(QString::fromStdString(etu->getNom()));
    prenomEtu_->setText(QString::fromStdString(etu->getPrenom()));
    adrPostEtu_->setText(QString::fromStdString(etu->getAdrPost()));
    adrElecEtu_->setText(QString::fromStdString(etu->getAdrEl()));
}

void Fenetre::setCreateEtu(QModelIndex index)
{
    createEtu_->setHidden(false);
    resetEtu_->setHidden(false);
    modifEtu_->setHidden(true);
    supprimerEtu_->setHidden(true);
    noEtu_->setDisabled(false);
    razEtu();
}

void Fenetre::modifEtudiant()
{
    QItemSelectionModel* selection = getBoiteDialog()->getTreeModif()->selectionModel();
    QModelIndex index = selection->currentIndex();
    control_.ModifierEtudiant(noEtu_->text(), nomEtu_->text(), prenomEtu_->text(), adrPostEtu_->text(), adrElecEtu_->text());
    control_.refreshTreeViewEtu(getBoiteDialog()->getModel(MODELTYPE_ETUDIANT));
    getBoiteDialog()->getTreeModif()->expand(index);
}

void Fenetre::supprEtudiant()
{
    control_.SupprimerEtudiant(noEtu_->text());
    control_.refreshTreeViewEns(getBoiteDialog()->getModel(MODELTYPE_ETUDIANT));
    if(getBoiteDialog()->getTreeModif()->model()->rowCount()!=0)
    {
        getBoiteDialog()->getTreeModif()->expand(getBoiteDialog()->getModel(MODELTYPE_ETUDIANT)->index(0,0));
    }
    else
    {
        setCreateEtu(QModelIndex());
    }
}

/*méthode appliqué au enseignant*/
void Fenetre::creerEnseignant()
{
    control_.ajouterEnseignant(noEns_->text(), nomEns_->text(), prenomEns_->text(), adrPostEns_->text(), adrElecEns_->text());
    control_.refreshTreeViewEns(getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT));
    razEns();
}

void Fenetre::razEns()
{
    noEns_->clear();
    nomEns_->clear();
    prenomEns_->clear();
    adrPostEns_->clear();
    adrElecEns_->clear();
}

void Fenetre::ajoutEnseignant()
{
    QStringList* liste = new QStringList();
    control_.getListEns(liste);
    dia_->setModel(*liste);
    dia_->setTypeModel(MODELTYPE_ENSEIGNANT);
    dia_->move(pos());
    dia_->show();
    delete liste;
}

void Fenetre::getAnswerEns(QModelIndex index)
{
   ensModule_ = control_.getEnseignant(index.row());
   idEnsLabel_->setText(QString::fromStdString(ensModule_->getNoen()));
   nomEnsLabel_->setText(QString::fromStdString(ensModule_->getNom()));
   prenomEnsLabel_->setText(QString::fromStdString(ensModule_->getPrenom()));
}

void Fenetre::getDataEns(QModelIndex index)
{
    createEns_->setHidden(true);
    resetEns_->setHidden(true);
    modifEns_->setHidden(false);
    supprimerEns_->setHidden(false);
    noEns_->setDisabled(true);
    /*fait en sorte qu'il n'y ai qu'un objet d'ouvert*/
    CheckExpended(index);
    QString noEns = index.data().toString().split(QRegExp(" "), QString::SkipEmptyParts ).last();
    Enseignant* ens = (control_.getEnseignant(noEns.toStdString()));
    noEns_->setText(QString::fromStdString(ens->getNoen()));
    nomEns_->setText(QString::fromStdString(ens->getNom()));
    prenomEns_->setText(QString::fromStdString(ens->getPrenom()));
    adrPostEns_->setText(QString::fromStdString(ens->getAdrPost()));
    adrElecEns_->setText(QString::fromStdString(ens->getAdrEl()));
}

void Fenetre::setCreateEns(QModelIndex index)
{
    createEns_->setHidden(false);
    resetEns_->setHidden(false);
    modifEns_->setHidden(true);
    supprimerEns_->setHidden(true);
    noEns_->setDisabled(false);
    razEns();
}

void Fenetre::modifEnseignant()
{
    QItemSelectionModel* selection = getBoiteDialog()->getTreeModif()->selectionModel();
    QModelIndex index = selection->currentIndex();
    control_.ModifierEnseignant(noEns_->text(), nomEns_->text(), prenomEns_->text(), adrPostEns_->text(), adrElecEns_->text());
    control_.refreshTreeViewEns(getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT));
    getBoiteDialog()->getTreeModif()->expand(index);
}

void Fenetre::supprEnseignant()
{
    control_.SupprimerEnseignant(noEns_->text());
    control_.refreshTreeViewEns(getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT));
    if(getBoiteDialog()->getTreeModif()->model()->rowCount()!=0)
    {
        getBoiteDialog()->getTreeModif()->expand(getBoiteDialog()->getModel(MODELTYPE_ENSEIGNANT)->index(0,0));
    }
    else
    {
        setCreateEns(QModelIndex());
    }
}

/*méthode appliqué au salle*/
void Fenetre::creerSalle()
{
    if(radioTypeCM_->isChecked())
        control_.ajouterSalleCM(noSalle_->text(), capacite_->text(), checkVisioConf_->isChecked());
    else if(radioTypeTD_->isChecked())
        control_.ajouterSalleTD(noSalle_->text(), capacite_->text(), checkVideoProj_->isChecked());
    else if(radioTypeTP_->isChecked())
        control_.ajouterSalleTP(noSalle_->text(), capacite_->text(), nbMachine_->text());
    control_.refreshTreeViewSalle(getBoiteDialog()->getModel(MODELTYPE_SALLE));
    razSalle();
}

void Fenetre::razSalle()
{
    noSalle_->clear();
    capacite_->clear();
    checkVideoProj_->setChecked(false);
    checkVisioConf_->setChecked(false);
    nbMachine_->clear();
}

void Fenetre::getDataSalle(QModelIndex index)
{
    if(index.parent()!=QModelIndex())
    {
        createSalle_->setHidden(true);
        resetSalle_->setHidden(true);
        modifSalle_->setHidden(false);
        supprimerSalle_->setHidden(false);
        noSalle_->setDisabled(true);
        CheckExpended(index);
        getBoiteDialog()->getTreeModif()->expand(index.parent());
        radioTypeCM_->setDisabled(true);
        radioTypeTD_->setDisabled(true);
        radioTypeTP_->setDisabled(true);
        int noSalle = index.data().toString().split(QRegExp(" "), QString::SkipEmptyParts).last().toInt();
        Salle* s;
        if(index.parent().data().toString().contains(QString("CM")))
        {
            SalleCM* scm = control_.getSalleCM(noSalle);
            s = scm;
            radioTypeCM_->setChecked(true);
            nbMachine_->setHidden(true);
            checkVideoProj_->setHidden(true);
            checkVisioConf_->setHidden(false);
            checkVisioConf_->setChecked(scm->getVisioConf());
        }
        else if(index.parent().data().toString().contains(QString("TD")))
        {
            SalleTD* sTD = control_.getSalleTD(noSalle);
            s = sTD;
            radioTypeTD_->setChecked(true);
            nbMachine_->setHidden(true);
            checkVisioConf_->setHidden(true);
            checkVideoProj_->setHidden(false);
            checkVideoProj_->setChecked(sTD->getVideoProj());
        }
        else
        {//salle de TP
            SalleTP* stp = control_.getSalleTP(noSalle);
            s = stp;
            radioTypeTP_->setChecked(true);
            checkVideoProj_->setHidden(true);
            checkVisioConf_->setHidden(true);
            nbMachine_->setHidden(false);
            nbMachine_->setText(QString::number(stp->getNbrMachine()));
        }
        noSalle_->setText(QString::number(s->getNumSalle()));
        capacite_->setText(QString::number(s->getCapacite()));
    }
}

void Fenetre::setCreateSalle(QModelIndex index)
{

    if(index.parent()==QModelIndex())
    {
        int i = 0;
        QModelIndex ind = index.child(0,0);
        while(ind != QModelIndex()){
            getBoiteDialog()->getTreeModif()->collapse(ind);
            ++i;
            ind = ind.sibling(i,0);
        }
    }
    createSalle_->setHidden(false);
    resetSalle_->setHidden(false);
    modifSalle_->setHidden(true);
    supprimerSalle_->setHidden(true);
    noSalle_->setDisabled(false);
    radioTypeCM_->setDisabled(false);
    radioTypeTD_->setDisabled(false);
    radioTypeTP_->setDisabled(false);
    razSalle();
}

void Fenetre::modifSalle()
{
    QItemSelectionModel* selection = getBoiteDialog()->getTreeModif()->selectionModel();
    QModelIndex index = selection->currentIndex();
    if(index.data().toString().contains(QString("CM")))
    {
        control_.ModifierSalleCM(noSalle_->text(), capacite_->text(), checkVisioConf_->isChecked());
    }
    else if(index.parent().data().toString().contains(QString("TD")))
    {
        control_.ModifierSalleTD(noSalle_->text(), capacite_->text(), checkVideoProj_->isChecked());
    }
    else
    {//salle TP
        control_.ModifierSalleTP(noSalle_->text(), capacite_->text(), nbMachine_->text());
    }
    control_.refreshTreeViewSalle(getBoiteDialog()->getModel(MODELTYPE_SALLE));
    int i = 0;
    QModelIndex ind = index.child(0,0);
    std::cout << (ind.data().toString().split(" ", QString::SkipEmptyParts).last() == noSalle_->text()) << std::endl;
    while(ind != QModelIndex() && ind.data().toString().split(" ", QString::SkipEmptyParts).last() != noSalle_->text()){
        ++i;
        ind = ind.sibling(i,0);
    }
    std::cout << ind.data().toString().toStdString() << std::endl;
    getBoiteDialog()->getTreeModif()->expand(ind.parent());
    setCreateSalle(ind);
}

void Fenetre::supprSalle()
{
    QItemSelectionModel* selection = getBoiteDialog()->getTreeModif()->selectionModel();
    QModelIndex index = selection->currentIndex();
    if(index.data().toString().contains(QString("CM")))
    {
        control_.SupprimerSalleCM(noSalle_->text());
    }
    else if(index.data().toString().contains(QString("TD")))
    {
        control_.SupprimerSalleTD(noSalle_->text());
    }
    else
    {
        control_.SupprimerSalleTP(noSalle_->text());
    }
    control_.refreshTreeViewSalle(getBoiteDialog()->getModel(MODELTYPE_SALLE));
    std::cout << index.child(0,0).data().toString().toStdString() << std::endl;
    if(index.child(0,0)!=QModelIndex())
    {
        getBoiteDialog()->getTreeModif()->expand(index);
        getBoiteDialog()->getTreeModif()->expand(index.child(0,0));
    }
    else
    {
        setCreateSalle(index);
    }
}

void Fenetre::ajoutSalle()
{
    QStringList* liste = new QStringList();
    control_.getListSalle(liste);
    dia_->setModel(*liste);
    dia_->setTypeModel(MODELTYPE_SALLE);
    dia_->move(pos());
    dia_->show();
    delete liste;
}

void Fenetre::getAnswerSalle(QModelIndex index)
{
    if(index.data().toString().contains(QRegExp("CM")))
    {
        salleCre_ = control_.getSalleCM(index.data().toString().split(QRegExp(" ")).last().toInt());
    }
    else if(index.data().toString().contains(QRegExp("TD")))
    {
        salleCre_ = control_.getSalleTD(index.data().toString().split(QRegExp(" ")).last().toInt());
    }
    else
    {
        salleCre_ = control_.getSalleTP(index.data().toString().split(QRegExp(" ")).last().toInt());
    }
    numSalleCre_->setText(QString("Salle n° : ") + QString::number(salleCre_->getNumSalle()));
}

/*methodes s'appliquant aux modules*/
void Fenetre::creerModule()
{
    Enseignant* ens = control_.getEnseignant(idEnsLabel_->text().toStdString());
    control_.ajouterModule(idMod_->text(), titreMod_->text(), nbHCM_->text(), nbHTD_->text(), nbHTP_->text(), ens);
    control_.refreshTreeViewMod(getBoiteDialog()->getModel(MODELTYPE_MODULE));
    razModule();
}

void Fenetre::razModule()
{
    idMod_->clear();
    titreMod_->clear();
    idEnsLabel_->clear();
    nomEnsLabel_->clear();
    prenomEnsLabel_->clear();
    ensModule_ = 0;
    nbHCM_->setText(QString("8"));
    nbHTD_->setText(QString("16"));
    nbHTP_->setText(QString("16"));
}

void Fenetre::getDataModule(QModelIndex index)
{
    createModule_->setHidden(true);
    resetModule_->setHidden(true);
    modifModule_->setHidden(false);
    supprModule_->setHidden(false);
    idMod_->setDisabled(true);
    nbHCM_->setDisabled(true);
    nbHTD_->setDisabled(true);
    nbHTP_->setDisabled(true);
    CheckExpended(index);
    QString idMod = index.data().toString().split(QRegExp(" ")).last();
    Module* mod = control_.getModule(idMod.toInt());
    idMod_->setText(QString::number(mod->getIdMod()));
    titreMod_->setText(QString::fromStdString(mod->getTitre()));
    nbHCM_->setText(QString::number(mod->getHCM()));
    nbHTD_->setText(QString::number(mod->getHTD()));
    nbHTP_->setText(QString::number(mod->getHTP()));
    idEnsLabel_->setText(QString::fromStdString(mod->getEnsResp()->getNoen()));
    nomEnsLabel_->setText(QString::fromStdString(mod->getEnsResp()->getNom()));
    prenomEnsLabel_->setText(QString::fromStdString(mod->getEnsResp()->getPrenom()));
    ajoutEns_->setText("Changer Enseignant");
}

void Fenetre::setCreateModule(QModelIndex index)
{
    createModule_->setHidden(false);
    resetModule_->setHidden(false);
    modifModule_->setHidden(true);
    supprModule_->setHidden(true);
    idMod_->setDisabled(false);
    nbHCM_->setDisabled(false);
    nbHTD_->setDisabled(false);
    nbHTP_->setDisabled(false);
    razModule();
}

void Fenetre::supprModule()
{
    control_.SupprimerModule(idMod_->text());
    control_.refreshTreeViewMod(getBoiteDialog()->getModel(MODELTYPE_MODULE));
    if(getBoiteDialog()->getTreeModif()->model()->rowCount()!=0)
    {
        getBoiteDialog()->getTreeModif()->expand(getBoiteDialog()->getModel(MODELTYPE_MODULE)->index(0,0));
    }
    else
    {
        setCreateModule(QModelIndex());
    }

}

void Fenetre::ajoutModule()
{
    QStringList* liste = new QStringList();
    control_.getListModule(liste);
    dia_->setModel(*liste);
    dia_->setTypeModel(MODELTYPE_MODULE);
    dia_->move(pos());
    dia_->show();
    delete liste;
}

void Fenetre::getAnswerModule(QModelIndex index)
{
    modCre_ = control_.getModule(index.data().toString().split(QRegExp(" ")).last().toInt());
    idModCre_->setText(QString("Id du module : ") + QString::number(modCre_->getIdMod()));
}

/*méthodes s'appliquant au groupe*/
void Fenetre::creerGroupe()
{
    control_.ajouterGroupe(nomGrp_->text());
    control_.refreshTreeViewGrp(getBoiteDialog()->getModel(MODELTYPE_GROUPE));
    razGroupe();
}

void Fenetre::razGroupe()
{
    nomGrp_->clear();
}

void Fenetre::getDataGroupe(QModelIndex index)
{
    createGrp_->setHidden(true);
    resetGrp_->setHidden(true);
    modifGrp_->setHidden(false);
    supprGrp_->setHidden(false);
    nomGrp_->setDisabled(true);
    CheckExpended(index);
    QString nomGrp = index.data().toString().split(QRegExp(" ")).last();
    Groupe* grp = control_.getGroupe(nomGrp.toStdString());
    nomGrp_->setText(QString::fromStdString(grp->getNomGroupe()));
}

void Fenetre::setCreateGroupe(QModelIndex index)
{
    createGrp_->setHidden(false);
    resetGrp_->setHidden(false);
    modifGrp_->setHidden(true);
    supprGrp_->setHidden(true);
    nomGrp_->setDisabled(false);
    razGroupe();
}

void Fenetre::supprGroupe()
{
    control_.SupprimerGroupe(nomGrp_->text());
    control_.refreshTreeViewGrp(getBoiteDialog()->getModel(MODELTYPE_GROUPE));
    if(getBoiteDialog()->getTreeModif()->model()->rowCount()!=0)
    {
        getBoiteDialog()->getTreeModif()->expand(getBoiteDialog()->getModel(MODELTYPE_GROUPE)->index(0,0));
    }
    else
    {
        setCreateGroupe(QModelIndex());
    }
}

void Fenetre::ajoutGroupe()
{
    QStringList* liste = new QStringList();
    control_.getListGroupe(liste);
    dia_->setModel(*liste);
    dia_->setTypeModel(MODELTYPE_GROUPE);
    dia_->move(pos());
    dia_->show();
    delete liste;
}

void Fenetre::getAnswerGroupe(QModelIndex index)
{
    grpCre_ = control_.getGroupe(index.data().toString().split(QRegExp(" ")).last().toStdString());
    nomGrpCre_->setText(QString("Groupe ") + QString::fromStdString(grpCre_->getNomGroupe()));
}

/*méthodes appliqué au creneaux*/

void Fenetre::creerCreneau()
{
    QStringList l = dateEdit_->text().split(QRegExp("/"));
    QDate* d = new QDate(l.at(2).toInt(), l.at(1).toInt(), l.at(0).toInt());
    control_.ajouterCreneau(d, heureEdit_->text().toInt(), salleCre_, grpCre_, modCre_);
    control_.refreshTreeViewCre(getBoiteDialog()->getModel(MODELTYPE_CRENEAU));
    razCreneau();
    delete d;
}

void Fenetre::razCreneau()
{
    dateEdit_->clear();
    heureEdit_->clear();
    salleCre_ = 0;
    grpCre_ = 0;
    modCre_ = 0;
    numSalleCre_->clear();
    nomGrpCre_->clear();
    idModCre_->clear();
}
